"""
Main entry point for the Word Document MCP Server.
Acts as the central controller for the MCP server that handles Word document operations.
Supports multiple transports: stdio, sse, and streamable-http using standalone FastMCP.
"""

import os
import sys
# Set required environment variable for FastMCP 2.8.1+
os.environ.setdefault('FASTMCP_LOG_LEVEL', 'INFO')
from fastmcp import FastMCP
from word_document_server.tools import (
    document_tools,
    content_tools,
    format_tools,
    protection_tools,
    footnote_tools,
    extended_document_tools
)
def get_transport_config():
    """
    Get transport configuration from environment variables.
    
    Returns:
        dict: Transport configuration with type, host, port, and other settings
    """
    # Default configuration
    config = {
        'transport': 'stdio',  # Default to stdio for backward compatibility
        'host': '127.0.0.1',
        'port': 8000,
        'path': '/mcp',
        'sse_path': '/sse'
    }
    
    # Override with environment variables if provided
    transport = os.getenv('MCP_TRANSPORT', 'stdio').lower()
    print(f"Transport: {transport}")
    # Validate transport type
    valid_transports = ['stdio', 'streamable-http', 'sse']
    if transport not in valid_transports:
        print(f"Warning: Invalid transport '{transport}'. Falling back to 'stdio'.")
        transport = 'stdio'
    
    config['transport'] = transport
    config['host'] = os.getenv('MCP_HOST', config['host'])
    config['port'] = int(os.getenv('MCP_PORT', config['port']))
    config['path'] = os.getenv('MCP_PATH', config['path'])
    config['sse_path'] = os.getenv('MCP_SSE_PATH', config['sse_path'])
    
    return config


def setup_logging(debug_mode):
    """
    Setup logging based on debug mode.
    
    Args:
        debug_mode (bool): Whether to enable debug logging
    """
    import logging
    
    if debug_mode:
        logging.basicConfig(
            level=logging.DEBUG,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        print("Debug logging enabled")
    else:
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )


# Initialize FastMCP server
mcp = FastMCP("Word Document Server")


def register_tools():
    """Register all tools with the MCP server using FastMCP decorators."""
    
    # Document tools (create, copy, info, etc.)
    @mcp.tool()
    def create_document(filename: str, title: str = None, author: str = None):
        """
        创建一个新的Word文档，并可选设置标题和作者。
        
        参数：
            filename (str): Word文档文件名（含路径，如不包含.docx扩展名会自动添加）
            title (str, 可选): 文档标题，默认为None（无标题）
            author (str, 可选): 作者名，默认为None（无作者信息）
        """
        return document_tools.create_document(filename, title, author)
    
    @mcp.tool()
    def copy_document(source_filename: str, destination_filename: str = None):
        """
        复制一个Word文档。
        
        参数：
            source_filename (str): 源Word文档文件名（含路径）
            destination_filename (str, 可选): 目标文件名（含路径），默认为None（自动生成带副本后缀的文件名）
        """
        return document_tools.copy_document(source_filename, destination_filename)
    
    @mcp.tool()
    def get_document_info(filename: str):
        """
        获取Word文档的基本信息。
        
        参数：
            filename (str): Word文档文件名（含路径）
        """
        return document_tools.get_document_info(filename)
    
    @mcp.tool()
    def get_document_text(filename: str):
        """
        提取Word文档中的全部文本内容。
        
        参数：
            filename (str): Word文档文件名（含路径）
        """
        return document_tools.get_document_text(filename)
    
    @mcp.tool()
    def get_document_outline(filename: str):
        """
        获取Word文档的大纲结构。
        
        参数：
            filename (str): Word文档文件名（含路径）
        """
        return document_tools.get_document_outline(filename)
    
    @mcp.tool()
    def list_available_documents(directory: str = "."):
        """
        列出指定目录下所有.docx文件。
        
        参数：
            directory (str, 可选): 目录路径，默认为当前目录（"."）
        """
        return document_tools.list_available_documents(directory)
    
    # Content tools (paragraphs, headings, tables, etc.)
    @mcp.tool()
    def add_paragraph(filename: str, text: str, style: str = None, font_name: str = 'Microsoft YaHei', position: int = None):
        """
        向Word文档添加一个段落。
        
        参数：
            filename (str): Word文档文件名（含路径）
            text (str): 段落内容
            style (str, 可选): 段落样式名，默认为None（使用默认样式）
            font_name (str, 可选): 字体名，默认为Microsoft YaHei
            position (int, 可选): 插入位置（段落索引，从0开始），默认为None（末尾插入）
                                 position=0表示插入到文档开头
                                 position=1表示插入到第一个段落之前
                                 position=2表示插入到第二个段落之前，以此类推
        """
        return content_tools.add_paragraph(filename, text, style, font_name, position)
    
    @mcp.tool()
    def add_heading(filename: str, text: str, level: int = 1, font_name: str = 'Microsoft YaHei', position: int = None):
        """
        向Word文档添加一个标题。
        
        参数：
            filename (str): Word文档文件名（含路径）
            text (str): 标题内容
            level (int, 可选): 标题级别，1为最高级，9为最低级，默认为1
            font_name (str, 可选): 字体名，默认为Microsoft YaHei
            position (int, 可选): 插入位置（段落索引，从0开始），默认为None（末尾插入）
                                 position=0表示插入到文档开头
                                 position=1表示插入到第一个段落之前
                                 position=2表示插入到第二个段落之前，以此类推
        """
        return content_tools.add_heading(filename, text, level, font_name, position)
    
    @mcp.tool()
    def add_picture(filename: str, image_path: str, width: float = None):
        """
        向Word文档插入一张图片。
        
        参数：
            filename (str): Word文档文件名（含路径）
            image_path (str): 图片文件路径（支持常见格式：jpg, png, gif, bmp等）
            width (float, 可选): 图片宽度（英寸），默认为None（保持原始大小）
        """
        return content_tools.add_picture(filename, image_path, width)
    
    @mcp.tool()
    def add_table(filename: str, rows: int, cols: int, data: list = None, position: int = None, font_name: str = 'Microsoft YaHei'):
        """
        向Word文档添加一个表格。
        
        参数：
            filename (str): Word文档文件名（含路径）
            rows (int): 表格行数（必须大于0）
            cols (int): 表格列数（必须大于0）
            data (list, 可选): 填充表格的二维数组，格式为[[row1_col1, row1_col2], [row2_col1, row2_col2]]，默认为None
            position (int, 可选): 插入位置（段落索引，从0开始），默认为None（末尾插入）
                                 position=0表示插入到文档开头
                                 position=1表示插入到第一个段落之前
                                 position=2表示插入到第二个段落之前，以此类推
            font_name (str, 可选): 表格内文字的字体名，默认为Microsoft YaHei
        """
        return content_tools.add_table(filename, rows, cols, data, position, font_name)
    
    @mcp.tool()
    def add_page_break(filename: str):
        """
        在Word文档末尾插入分页符。
        
        参数：
            filename (str): Word文档文件名（含路径）
        """
        return content_tools.add_page_break(filename)
    
    @mcp.tool()
    def delete_paragraph(filename: str, paragraph_index: int):
        """
        删除Word文档中指定索引的段落。
        
        参数：
            filename (str): Word文档文件名（含路径）
            paragraph_index (int): 段落索引（从0开始）
                                 0表示第一个段落，1表示第二个段落，以此类推
                                 删除后，后续段落的索引会自动前移
        """
        return content_tools.delete_paragraph(filename, paragraph_index)
    
    @mcp.tool()
    def search_and_replace(filename: str, find_text: str, replace_text: str):
        """
        在Word文档中查找并替换所有指定文本。
        
        参数：
            filename (str): Word文档文件名（含路径）
            find_text (str): 要查找的文本（区分大小写）
            replace_text (str): 替换为的文本
        """
        return content_tools.search_and_replace(filename, find_text, replace_text)
    
    # Format tools (styling, text formatting, etc.)
    @mcp.tool()
    def create_custom_style(filename: str, style_name: str, bold: bool = None, 
                          italic: bool = None, font_size: int = None, 
                          font_name: str = None, color: str = None, 
                          base_style: str = None):
        """
        在Word文档中创建自定义样式。
        
        参数：
            filename (str): Word文档文件名（含路径）
            style_name (str): 样式名称（必须唯一）
            bold (bool, 可选): 是否加粗，默认为None（保持基础样式设置）
            italic (bool, 可选): 是否斜体，默认为None（保持基础样式设置）
            font_size (int, 可选): 字号（点数），默认为None（保持基础样式设置）
            font_name (str, 可选): 字体名，默认为None（保持基础样式设置）
            color (str, 可选): 字体颜色（如'red', 'blue', '#FF0000'），默认为None（保持基础样式设置）
            base_style (str, 可选): 基础样式名（如'Normal', 'Heading 1'），默认为None（基于Normal样式）
        """
        return format_tools.create_custom_style(
            filename, style_name, bold, italic, font_size, font_name, color, base_style
        )
    
    @mcp.tool()
    def format_text(filename: str, paragraph_index: int, start_pos: int, end_pos: int,
                   bold: bool = None, italic: bool = None, underline: bool = None,
                   color: str = None, font_size: int = None, font_name: str = None):
        """
        格式化Word文档中指定段落的部分文本。
        
        参数：
            filename (str): Word文档文件名（含路径）
            paragraph_index (int): 段落索引（从0开始）
                                 0表示第一个段落，1表示第二个段落，以此类推
            start_pos (int): 起始字符位置（包含，从0开始）
            end_pos (int): 结束字符位置（包含，必须大于start_pos）
            bold (bool, 可选): 是否加粗，默认为None（保持原格式）
            italic (bool, 可选): 是否斜体，默认为None（保持原格式）
            underline (bool, 可选): 是否下划线，默认为None（保持原格式）
            color (str, 可选): 字体颜色（如'red', 'blue', '#FF0000'），默认为None（保持原颜色）
            font_size (int, 可选): 字号（点数），默认为None（保持原字号）
            font_name (str, 可选): 字体名，默认为None（保持原字体）
        """
        return format_tools.format_text(
            filename, paragraph_index, start_pos, end_pos, bold, italic, 
            underline, color, font_size, font_name
        )
    
    @mcp.tool()
    def format_table(filename: str, table_index: int, has_header_row: bool = None,
                    border_style: str = None, shading: list = None):
        """
        格式化Word文档中的表格。
        
        参数：
            filename (str): Word文档文件名（含路径）
            table_index (int): 表格索引（从0开始）
                             0表示第一个表格，1表示第二个表格，以此类推
            has_header_row (bool, 可选): 是否将第一行设为表头，默认为None（保持原设置）
            border_style (str, 可选): 边框样式（如'single', 'double', 'dashed'），默认为None（保持原样式）
            shading (list, 可选): 单元格底纹设置，格式为[行索引, 列索引, 颜色]，默认为None（无底纹）
        """
        return format_tools.format_table(filename, table_index, has_header_row, border_style, shading)
    
    # Protection tools
    @mcp.tool()
    def protect_document(filename: str, password: str):
        """
        为Word文档添加密码保护。
        
        参数：
            filename (str): Word文档文件名（含路径）
            password (str): 密码（用于保护文档）
        """
        return protection_tools.protect_document(filename, password)
    
    @mcp.tool()
    def unprotect_document(filename: str, password: str):
        """
        移除Word文档的密码保护。
        
        参数：
            filename (str): Word文档文件名（含路径）
            password (str): 密码（用于解除文档保护）
        """
        return protection_tools.unprotect_document(filename, password)
    
    # Footnote tools
    @mcp.tool()
    def add_footnote_to_document(filename: str, paragraph_index: int, footnote_text: str):
        """
        向Word文档指定段落添加脚注。
        
        参数：
            filename (str): Word文档文件名（含路径）
            paragraph_index (int): 段落索引（从0开始）
                                 0表示第一个段落，1表示第二个段落，以此类推
            footnote_text (str): 脚注内容（将显示在页面底部）
        """
        return footnote_tools.add_footnote_to_document(filename, paragraph_index, footnote_text)
    
    @mcp.tool()
    def add_endnote_to_document(filename: str, paragraph_index: int, endnote_text: str):
        """
        向Word文档指定段落添加尾注。
        
        参数：
            filename (str): Word文档文件名（含路径）
            paragraph_index (int): 段落索引（从0开始）
                                 0表示第一个段落，1表示第二个段落，以此类推
            endnote_text (str): 尾注内容（将显示在文档末尾）
        """
        return footnote_tools.add_endnote_to_document(filename, paragraph_index, endnote_text)
    
    @mcp.tool()
    def customize_footnote_style(filename: str, numbering_format: str = "1, 2, 3",
                                start_number: int = 1, font_name: str = None,
                                font_size: int = None):
        """
        自定义Word文档脚注的编号和样式。
        
        参数：
            filename (str): Word文档文件名（含路径）
            numbering_format (str, 可选): 编号格式，默认为"1, 2, 3"
            start_number (int, 可选): 起始编号，默认为1
            font_name (str, 可选): 字体名，默认为None（保持默认字体）
            font_size (int, 可选): 字号（点数），默认为None（保持默认字号）
        """
        return footnote_tools.customize_footnote_style(
            filename, numbering_format, start_number, font_name, font_size
        )
    
    # Extended document tools
    @mcp.tool()
    def get_paragraph_text_from_document(filename: str, paragraph_index: int):
        """
        获取Word文档指定段落的文本内容。
        
        参数：
            filename (str): Word文档文件名（含路径）
            paragraph_index (int): 段落索引（从0开始）
                                 0表示第一个段落，1表示第二个段落，以此类推
        """
        return extended_document_tools.get_paragraph_text_from_document(filename, paragraph_index)
    
    @mcp.tool()
    def find_text_in_document(filename: str, text_to_find: str, match_case: bool = True,
                             whole_word: bool = False):
        """
        查找Word文档中所有指定文本的位置。
        
        参数：
            filename (str): Word文档文件名（含路径）
            text_to_find (str): 要查找的文本
            match_case (bool, 可选): 是否区分大小写，默认为True
            whole_word (bool, 可选): 是否全字匹配，默认为False
        """
        return extended_document_tools.find_text_in_document(
            filename, text_to_find, match_case, whole_word
        )
    
    @mcp.tool()
    def convert_to_pdf(filename: str, output_filename: str = None):
        """
        将Word文档转换为PDF格式。
        
        参数：
            filename (str): Word文档文件名（含路径）
            output_filename (str, 可选): 输出PDF文件名（含路径），默认为None（自动生成同名PDF文件）
        """
        return extended_document_tools.convert_to_pdf(filename, output_filename)


def run_server():
    """Run the Word Document MCP Server with configurable transport."""
    # Get transport configuration
    config = get_transport_config()
    
    # Setup logging
    # setup_logging(config['debug'])
    
    # Register all tools
    register_tools()
    
    # Print startup information
    transport_type = config['transport']
    print(f"Starting Word Document MCP Server with {transport_type} transport...")
    
    # if config['debug']:
    #     print(f"Configuration: {config}")
    
    try:
        if transport_type == 'stdio':
            # Run with stdio transport (default, backward compatible)
            print("Server running on stdio transport")
            mcp.run(transport='stdio')
            
        elif transport_type == 'streamable-http':
            # Run with streamable HTTP transport
            print(f"Server running on streamable-http transport at http://{config['host']}:{config['port']}{config['path']}")
            mcp.run(
                transport='streamable-http',
                host=config['host'],
                port=config['port'],
                path=config['path']
            )
            
        elif transport_type == 'sse':
            # Run with SSE transport
            print(f"Server running on SSE transport at http://{config['host']}:{config['port']}{config['sse_path']}")
            mcp.run(
                transport='sse',
                host=config['host'],
                port=config['port'],
                path=config['sse_path']
            )
            
    except KeyboardInterrupt:
        print("\nShutting down server...")
    except Exception as e:
        print(f"Error starting server: {e}")
        if config['debug']:
            import traceback
            traceback.print_exc()
        sys.exit(1)
    
    return mcp


def main():
    """Main entry point for the server."""
    run_server()


if __name__ == "__main__":
    main()